package com.example.leetcode.sort;

import java.util.Arrays;

/**
 * 冒泡排序
 * 思路：外层循环，次数为数组长度减一，因为最多就有这么多的元素，需要排序
 *      内存循环，为需要移动位置的元素的，移动次数，但外层循环每循环一次，表示已经排好了一个元素
 *              内层循环需要排序的次数就少一次
 */
public class BubbleSort {
    public static void main(String[] args) {
        int arr[]={3, 9, -1, 10, -2};
        System.out.println("排序前：" + Arrays.toString(arr));
        sort2(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }
    // 思路：1、外层循环每次找出最大的值排序 2、内层循环，
    private static void sort(int[] nums){
        int temp = 0;
        // 外层循环次数为，数组长度减一，每一次的外层循环都会找出这次循环的最大值并放到对应的位置
        for (int i = 0; i < nums.length-1; i++) {
            // -1是因为每经历一次外层循环，内层循环需要比较的次数就减一
            for (int j = 0; j < nums.length - 1 - i; j++) {
                if (nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
    }
    // 练习
    private static void sort1(int[] nums){
        int temp = 0;
        // 外层循环，次数为nums.length - 1,因为最多有nums.length - 1个元素需要排序
        for (int i = 0; i < nums.length - 1; i++) {
            // 内层循环,nums.length - 1 - i是因为每经历一次外循环，内循环就可以少一次
            for(int j = 0; j < nums.length - 1 - i; j++){
                if(nums[j] > nums[j + 1]){
                    temp = nums[j + 1];
                    nums[j + 1] = nums[j];
                    nums[j] = temp;
                }
            }
        }
    }
    // 练习
    private static void sort2(int[] nums){
        int temp = 0;
        for (int i = 0; i < nums.length -1; i++) {
            for (int i1 = 0; i1 < nums.length - 1 - i; i1++) {
                if (nums[i1] > nums[i1 + 1]){
                    temp = nums[i1];
                    nums[i1] = nums[i1 + 1];
                    nums[i1 + 1] = temp;
                }
            }
        }
    }
}

